package staticdemo;

/**
 * 静态内部类演示
 * 
 * 静态内部类是使用static修饰的内部类。
 * 与非静态内部类不同，静态内部类不持有外部类的引用。
 */
public class StaticNestedClassDemo {
    
    private String outerField = "外部类实例字段";
    private static String staticOuterField = "外部类静态字段";
    
    /**
     * 静态内部类
     * 1. 不持有外部类实例的引用
     * 2. 可以直接访问外部类的静态成员
     * 3. 不能直接访问外部类的实例成员
     */
    public static class StaticNestedClass {
        private String nestedField = "静态内部类字段";
        
        public void display() {
            System.out.println("=== 静态内部类 ===");
            // 可以直接访问外部类的静态字段
            System.out.println("外部类静态字段: " + staticOuterField);
            
            // 不能直接访问外部类的实例字段
            // System.out.println(outerField); // 编译错误
            
            System.out.println("静态内部类字段: " + nestedField);
        }
        
        // 静态内部类中的静态方法
        public static void staticNestedMethod() {
            System.out.println("静态内部类的静态方法");
            System.out.println("访问外部类静态字段: " + staticOuterField);
        }
    }
    
    /**
     * 非静态内部类（内部类）
     * 1. 持有外部类实例的引用
     * 2. 可以访问外部类的所有成员（静态和实例）
     */
    public class InnerClass {
        private String innerField = "非静态内部类字段";
        
        public void display() {
            System.out.println("\n=== 非静态内部类 ===");
            // 可以访问外部类的静态字段
            System.out.println("外部类静态字段: " + staticOuterField);
            
            // 也可以访问外部类的实例字段
            System.out.println("外部类实例字段: " + outerField);
            
            System.out.println("非静态内部类字段: " + innerField);
        }
    }
    
    /**
     * 外部类方法
     */
    public void outerMethod() {
        System.out.println("外部类方法");
        System.out.println("访问外部类实例字段: " + outerField);
        System.out.println("访问外部类静态字段: " + staticOuterField);
    }
    
    public static void main(String[] args) {
        System.out.println("=== 静态内部类与非静态内部类对比 ===\n");
        
        // 创建静态内部类实例 - 不需要外部类实例
        StaticNestedClassDemo.StaticNestedClass nestedInstance = 
            new StaticNestedClassDemo.StaticNestedClass();
        nestedInstance.display();
        
        // 调用静态内部类的静态方法 - 不需要创建实例
        StaticNestedClass.staticNestedMethod();
        
        System.out.println();
        
        // 创建外部类实例
        StaticNestedClassDemo outerInstance = new StaticNestedClassDemo();
        outerInstance.outerMethod();
        
        // 创建非静态内部类实例 - 需要外部类实例
        StaticNestedClassDemo.InnerClass innerInstance = outerInstance.new InnerClass();
        innerInstance.display();
        
        System.out.println("\n=== 静态内部类与非静态内部类的主要区别 ===");
        System.out.println("1. 静态内部类：");
        System.out.println("   - 不依赖外部类实例，可以直接通过外部类名创建");
        System.out.println("   - 不持有外部类实例的引用，节省内存");
        System.out.println("   - 只能直接访问外部类的静态成员");
        System.out.println("   - 可以定义静态成员");
        
        System.out.println("\n2. 非静态内部类：");
        System.out.println("   - 必须依赖外部类实例才能创建");
        System.out.println("   - 持有外部类实例的引用");
        System.out.println("   - 可以直接访问外部类的所有成员");
        System.out.println("   - 不能定义静态成员（除了静态常量）");
        
        System.out.println("\n=== 实际应用场景 ===");
        System.out.println("静态内部类常用于：");
        System.out.println("1. 工具类，如Map.Entry");
        System.out.println("2. Builder模式，如之前的BuilderDemo.Builder");
        System.out.println("3. 当内部类不需要访问外部类实例成员时");
        
        System.out.println("\n非静态内部类常用于：");
        System.out.println("1. 需要访问外部类实例成员的场景");
        System.out.println("2. 事件监听器等需要与外部类紧密交互的场景");
    }
}